package com.hejing.方法引用与构造器引用;

import com.hejing.方法引用与构造器引用.data.Employee;
import org.junit.Test;

import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * ClassName: MethodRefTest
 * Package: com.hejing.方法引用与构造器引用
 * Description:
 *
 * @Author: HeJing
 * @Create: 2023-06-05 19:38
 * @Version: 1.0
 */
public class MethodRefTest {
    /**
     * 情况1: 对象 :: 实例方法
     */
    // Consumer中的void accept(T t)
    // PrintStream中的void println(T t)
    @Test
    public void test01(){
        // 1、最初的接口格式
        Consumer<String> con1 = new Consumer<String> () {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("hello");

        System.out.println("*************************");
        // 2、lambda表达式形式
        Consumer<String> con2 = s -> System.out.println(s);
        con2.accept("hello lambda");


        // 3、方法引用形式
        Consumer<String> con3 = System.out::println;
        con3.accept("hello functionRef");
    }

    // Supplier中的 T get()
    // Employee中的String getName()
    @Test
    public void test02(){
        Employee emp = new Employee(1001, "马化腾", 34, 6000.38);
        // 1、原始接口写法
        Supplier<String> sup1 = new Supplier<String>() {
            @Override
            public String get() {
                return emp.getName();
            }
        };
        System.out.println(sup1.get());

        // 2、lambda表达式写法
        Supplier<String> sup2 = () -> emp.getName();
        System.out.println(sup2.get());

        // 3、方法引用写法:
        Supplier<String> sup3 = emp::getName;
        System.out.println(sup3.get());
    }

    /**
     * 情况2: 类 :: 静态方法
     */
    // Comparator 中的 int compare(T t1, T t2)
    // Integer 中的 int compare(T t1, T t2)
    @Test
    public void test03(){
        // 1、使用原始接口的形式
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(com1.compare(12, 23));

        // 2、使用lambda表达式的形式
        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        System.out.println(com2.compare(123, 32));

        // 3、使用方法引用的形式
        Comparator<Integer> com3 = Integer::compare;
        System.out.println(com3.compare(123, 32));

    }

    // Function中的 R apply(T t)
    // Math中的Long round(Double d)
    @Test
    public void test04(){
        // 1、原始接口的形式
        Function<Double, Long> fun1 = new Function<Double, Long>() {
            @Override
            public Long apply(Double aDouble) {
                return Math.round(aDouble);
            }
        };

        // 2、lambda表达式写法
        Function<Double, Long> fun2 = aDouble -> Math.round(aDouble);

        // 3、方法引用的形式:
        Function<Double, Long> fun3 = Math::round;

    }

    /**
     * 情况3: 类 :: 实例方法
     */
    // Comparator中的int compare(T t1, T t2)
    // String中的 int t1.compareTo(t2)
    @Test
    public void test05(){

        // 1、最初的接口形式
        Comparator<String> com1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        };
        System.out.println(com1.compare("abd", "2332dd"));

        // 2、lambda表达式形式
        Comparator<String> com2 = (o1, o2) -> o1.compareTo(o2);
        System.out.println(com2.compare("23ds", "ds13"));

        // 3、方法引用形式
        Comparator<String> com3 = String::compareTo;
        System.out.println(com3.compare("3e23", "e2ew3"));
    }

    // BiPredicate中的boolean test(T t1, T t2)
    // String中的boolean t1.equals(t2)
    @Test
    public void test06(){

        // 1、使用原始接口的形式
        BiPredicate<String, String> bp1 = new BiPredicate<String, String>() {
            @Override
            public boolean test(String s, String s2) {
                return s.equals(s2);
            }
        };
        System.out.println(bp1.test("abd", "dwe"));

        // 2、使用lambda表达式的形式
        BiPredicate<String, String> bp2 = (s, s2) -> s.equals(s2);
        System.out.println(bp2.test("13", "13"));

        // 3、使用方法引用的形式
        BiPredicate<String, String> bp3 = String::equals;
        System.out.println(bp3.test("dad", "dsd"));
    }

    // Function中的 R apply(T t)
    // Employee 中的String getName();
    @Test
    public void test07(){

        Employee emp = new Employee(1002, "马云", 2, 19876.12);

        // 1、使用原始接口的形式
        Function<Employee, String> fun1 = new Function<Employee, String>() {
            @Override
            public String apply(Employee employee) {
                return employee.getName();
            }
        };
        System.out.println(fun1.apply(emp));

        // 2、使用lambda表达式的形式
        Function<Employee, String> fun2 = employee -> employee.getName();
        System.out.println(fun2.apply(emp));

        // 3、使用方法引用的形式
        Function<Employee, String> fun3 = Employee::getName;
        System.out.println(fun3.apply(emp));
    }
}























